(function(K) {
    
var Assert = YAHOO.util.Assert;

function getDependencies(callback) {
    K.classLoader().
    requires("tk.k90tools.lang.Reflect").
    load(function(I) { callback(I); });
}

K.classLoader(K.data("testConfig").basePath).
provides("tk.k90tools.lang.ReflectTest").
load(function(I) {
	
	var data = {
		"object" : {},
		"function" : function() {},
		"array" : [],
		"boolean" : false,
		"number" : 0,
		"null" : null,
		"undefined" : void 0,
		"arrayLike" : {length : 0},
		"argumentsLike" : arguments,
		"regexp" : /someRegexp/,
		"string" : ""
	};
	
	function assertDataType(expect, callback, dataType) {
		if (expect) {
			Assert.isTrue(callback(data[dataType]), "datatype: " + dataType);
		} else {
            Assert.isFalse(callback(data[dataType]), "datatype: " + dataType);
		}
	}
	
	function assertDataTypes(callback /*, dataType...*/ ) {
		var map = {};
		for (var i = 1, l = arguments.length; i < l; i++) {
			map[arguments[i]] = null;
		}
		
		for (var d in data) {
			if (data.hasOwnProperty(d)) {
				assertDataType(map.hasOwnProperty(d), callback, d);
			}
		}
	}
    
    return function() {
    	var test = new YAHOO.tool.TestCase({
            name : "tk.k90tools.lang.ReflectTest",
            
            testIsArray: function() {
            	getDependencies(function(I) {
            		test.resume(function() {
            			assertDataTypes(I.Reflect.isArray, "array");
            		});
            	});
            	
            	this.wait();
            },
        
            testIsBoolean: function() {
                getDependencies(function(I) {
                    test.resume(function() {
                        assertDataTypes(I.Reflect.isBoolean, "boolean");
                    });
                });
                
                this.wait();            	
            },
            
            testIsFunction: function() {
                getDependencies(function(I) {
                    test.resume(function() {
                    	assertDataTypes(I.Reflect.isFunction, "function");
                    });
                });
                this.wait();
            },
                
            testIsNull: function() {
                getDependencies(function(I) {
                    test.resume(function() {
                    	assertDataTypes(I.Reflect.isNull, "null");
                    });
                });
                this.wait();
            },
                
            testIsNumber: function() {
                getDependencies(function(I) {
                    test.resume(function() {
                    	assertDataTypes(I.Reflect.isNumber, "number");
                    });
                });
                this.wait();
            },
              
            testIsObject: function() {
                getDependencies(function(I) {
                    test.resume(function() {
                    	assertDataTypes(I.Reflect.isObject, "object", "function", "array", "arrayLike", "argumentsLike", "regexp");
                    });
                });
                this.wait();
            },
                
            testIsString: function() {
                getDependencies(function(I) {
                    test.resume(function() {
                    	assertDataTypes(I.Reflect.isString, "string");
                    });
                });
                this.wait();  	
            },
                
            testIsUndefined: function() {
                getDependencies(function(I) {
                    test.resume(function() {
                    	assertDataTypes(I.Reflect.isUndefined, "undefined");
                    });
                });
                this.wait();
            },
            
            testIsArrayLike : function() {
                getDependencies(function(I) {
                    test.resume(function() {
                    	assertDataTypes(I.Reflect.isArrayLike, "array", "arrayLike", "argumentsLike");
                    });
                });
                this.wait();
            },
            
            testIsArgumentsLike : function() {
                getDependencies(function(I) {
                    test.resume(function() {
                    	assertDataTypes(I.Reflect.isArgumentsLike, "argumentsLike");
                    });
                });
                this.wait();            	
            }
            
//            testHasOwnProperty : function() {
//                getDependencies(function(I) {
//                    test.resume(function() {
//                    	var Constr = function() { this.bar = true; };
//                    	Constr.prototype.foo = true;
//                    	var o = new Constr();
//                    	
//                    	Assert.isTrue(I.Reflect.hasOwnProperty(o, "bar"));
//                        Assert.isFalse(I.Reflect.hasOwnProperty(o, "foo"));
//                    });
//                });
//                this.wait();            	
//            }
        });
    }
});

})(k90tools);